home *** CD-ROM | disk | FTP | other *** search
/ CD Actual 80 / CD Actual 80 Julio-Agosto 2003.iso / Linux / LinuxGazette / lg / issue91 / misc / mathew / code / pvcl.c < prev    next >
Encoding:
C/C++ Source or Header  |  2003-05-20  |  33.8 KB  |  1,516 lines
  1. /*  Copyright (C) 2003 Cherry George Mathew <cherry@freeshell.org>
  2.  
  3.     This program is free software; you can redistribute it and/or modify
  4.     it under the terms of the GNU General Public License as published by
  5.     the Free Software Foundation; either version 2 of the License, or
  6.     (at your option) any later version.
  7.     
  8.     This program is distributed in the hope that it will be useful,
  9.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.     GNU General Public License for more details.
  12.     
  13.     You should have received a copy of the GNU General Public License
  14.     along with this program; if not, write to the Free Software
  15.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  16. */
  17.  
  18. #include <linux/version.h> 
  19. #include <linux/module.h>
  20. #include <linux/delay.h>
  21. #include <linux/errno.h>
  22. #include <linux/fs.h>
  23. #include <linux/kernel.h>
  24. #include <linux/sched.h>
  25. #include <linux/interrupt.h>
  26. #include <linux/kdev_t.h>
  27. #include "pvcard.h"
  28. #include "pvcl.h" 
  29. #include "pvproc.h"
  30. #include <asm/io.h>
  31. #include <asm/bitops.h>
  32.  
  33. /* const declarations and static allocations */
  34.  
  35. /* card ids ends with vendor id as marker. Number of cards is defined \
  36.  * as MAX_CARDS. Will add PCI_DEVICE_ID_CIRRUS_5465 Later.
  37.  */
  38. const int clgd54xx_card_id[]={PCI_DEVICE_ID_CIRRUS_5480,\
  39.                   PCI_DEVICE_ID_CIRRUS_5446,\
  40.                   PCI_VENDOR_ID_CIRRUS};
  41.  
  42. /* Decided against kmalloc for the moment. Would probably be efficient
  43.  * if we dealt with stuff like multiple cards, etc. not for the moment,
  44.  * though.
  45.  */
  46.  
  47.  
  48. /* Default max screen size hardcoded to ???? */
  49. static struct video_buffer vbuf_s = { 
  50. };
  51.  
  52. static struct video_picture vpict_s;
  53.  
  54. /* TODO: Chroma keying.....Default _no_ chromakeying bcos xawtv has no
  55.  *   support for it with V4L1. Someday.... Sigh ......*/
  56.  
  57. static struct video_window vwin_s = { 
  58. /*      chromakey:  GD_CHROMA_KEY,  */
  59. /*       flags:      VIDEO_WINDOW_CHROMAKEY   */
  60. };
  61.  
  62. /* Tuner properties hardcoded. */
  63. static struct video_tuner vtun_s = {
  64.     name:        "Television",
  65.     rangelow:    0,
  66.     rangehigh:   0x7FFFFFFF,
  67.     flags:       VIDEO_TUNER_PAL, 
  68.     mode:        VIDEO_MODE_PAL
  69. };
  70.  
  71. /* Single channel support at the moment. S-Video and Composite ignored. */
  72. static struct video_channel vchan_s = {
  73.     name:        "Television",
  74.     tuners:      1,
  75.     flags:       VIDEO_VC_TUNER | VIDEO_VC_AUDIO,
  76.     type:        VIDEO_TYPE_TV,
  77.     norm:        VIDEO_MODE_PAL
  78. };
  79.  
  80. static struct gd_status_t dstat_s = { 
  81.     vbuf_p:     &vbuf_s,
  82.     vwin_p:     &vwin_s,
  83.     vtun_p:     &vtun_s,
  84.     vchan_p:    &vchan_s,
  85.     vpict_p:    &vpict_s,
  86. };
  87.  
  88. /* Initializing a new adapter named clgd54xx. Right now, we'll make do 
  89.    with a static declaration. Not good enough for driving multiple cards.
  90. */
  91.  
  92.  
  93. static struct clgd54xx_card clgd54xx_card_info = {
  94.     spun_lock:    SPIN_LOCK_UNLOCKED,
  95.     drv_stat_p:   &dstat_s,
  96.     model:        PVCLPP_COMBO
  97. };
  98.  
  99. static struct i2c_algo_bit_data clgd54xx_bitbang_adap = {
  100.     data:         &clgd54xx_card_info,
  101.     setsda:       gd54xx_setsda,
  102.     setscl:       gd54xx_setscl,
  103.     getsda:       gd54xx_getsda,
  104.     getscl:       gd54xx_getscl,
  105.     udelay:       16,
  106.     mdelay:       10,
  107.     timeout:      200,
  108. };
  109.  
  110. static struct i2c_adapter clgd54xx_adap = {
  111.     name:        "clgd54xx",
  112.  
  113.     /* Now make i2c_adapter->algo_data point to our 
  114.      * i2c_algo_bit_data , ie; link adapter and algo.
  115.      */
  116.  
  117.     id:          I2C_ALGO_BIT | I2C_HW_B_BT848,
  118.     algo_data:   &clgd54xx_bitbang_adap,
  119. };
  120.  
  121. /* variable declarations and initializations */
  122.  
  123. unsigned int debug = 0;
  124. unsigned int re_entry = 0;
  125.  
  126. /* Adapter - Low level functions  */
  127.  
  128. /* Note:
  129.  * 5480 and 5446B can use either MMIO or PIO
  130.  * 5446A must use PIO
  131.  * 5465 must use MMIO
  132.  */
  133.  
  134. unsigned io_readb(unsigned port)
  135. {
  136.     vprintk("io_io_read on port %p\n", (char *) port);
  137.     return inb(port);
  138. }
  139.  
  140. void io_writeb(unsigned data, unsigned port)
  141. {
  142.     vprintk("io_io_write on port %p\n", (char *) port);
  143.     outb(data, port);
  144. } 
  145.  
  146. /***************  TODO: IMPLEMENT PCI MEM MAPPING *****************
  147.  
  148.  
  149. unsigned m_io_readb_proc(unsigned port)
  150. {
  151.     vprintk("m_io_read on port %p\n", (char *) port);
  152.     return readb(port);
  153. }
  154.  
  155. void m_io_writeb_proc(unsigned data, unsigned port)
  156. {
  157.     vprintk("m_io_write on port %p\n", (char *) port);
  158.     writeb(data, port);
  159. }
  160.  
  161. *************************************************************************/
  162. void gd_write_sr(struct clgd54xx_card *card_p,unsigned char datum,unsigned reg) 
  163. {
  164.     spin_lock_irqsave(&card_p->spun_lock, card_p->spinflags);
  165.     io_writeb(reg, card_p->gd_io_base + GD_SR_OFFSET); 
  166.     io_writeb(datum, card_p->gd_io_base + GD_SR_OFFSET + 1);
  167.     spin_unlock_irqrestore(&card_p->spun_lock, card_p->spinflags);
  168.  
  169. }
  170.  
  171.  
  172. void gd_write_gr(struct clgd54xx_card *card_p, unsigned char datum,unsigned reg) 
  173. { 
  174.         spin_lock_irqsave(&card_p->spun_lock,card_p->spinflags);
  175.     io_writeb(reg, card_p->gd_io_base + GD_GR_OFFSET); 
  176.     io_writeb(datum, card_p->gd_io_base + GD_GR_OFFSET + 1);
  177.     spin_unlock_irqrestore(&card_p->spun_lock,card_p->spinflags);
  178.  
  179. }
  180.  
  181. void gd_write_cr(struct clgd54xx_card *card_p, unsigned char datum,unsigned reg) 
  182. {
  183.         spin_lock_irqsave(&card_p->spun_lock, card_p->spinflags);
  184.     io_writeb(reg, card_p->gd_io_base + GD_CR_OFFSET);
  185.     io_writeb(datum, card_p->gd_io_base + GD_CR_OFFSET + 1);
  186.     spin_unlock_irqrestore(&card_p->spun_lock,card_p->spinflags);
  187.  
  188. }
  189.  
  190. unsigned gd_read_sr(struct clgd54xx_card *card_p, unsigned reg) 
  191. {
  192.     unsigned value;
  193.     spin_lock_irqsave(&card_p->spun_lock,card_p->spinflags);
  194.     io_writeb(reg, card_p->gd_io_base + GD_SR_OFFSET);
  195.     value = io_readb(card_p->gd_io_base + GD_SR_OFFSET + 1);
  196.     spin_unlock_irqrestore(&card_p->spun_lock,card_p->spinflags);
  197.     return value;
  198. }
  199.  
  200. unsigned gd_read_gr(struct clgd54xx_card *card_p, unsigned reg)
  201. {
  202.     unsigned value;
  203.         spin_lock_irqsave(&card_p->spun_lock, card_p->spinflags);
  204.     io_writeb(reg, card_p->gd_io_base + GD_GR_OFFSET);
  205.     value = io_readb(card_p->gd_io_base + GD_GR_OFFSET + 1);
  206.     spin_unlock_irqrestore(&card_p->spun_lock,card_p->spinflags);
  207.     return value;
  208. }
  209.  
  210. unsigned gd_read_cr(struct clgd54xx_card *card_p, unsigned reg)
  211. {
  212.     unsigned value;
  213.     spin_lock_irqsave(&card_p->spun_lock, card_p->spinflags);
  214.     io_writeb(reg, card_p->gd_io_base + GD_CR_OFFSET); 
  215.     value = io_readb(card_p->gd_io_base + GD_CR_OFFSET + 1);
  216.     spin_unlock_irqrestore(&card_p->spun_lock, card_p->spinflags);
  217.     return value;
  218. }
  219.  
  220.  
  221. void gd54xx_setsda (void *bit_adap_dat, int state)
  222. {
  223.     struct clgd54xx_card *data=bit_adap_dat;
  224.  
  225.     /* Switch on I2C interface */
  226.     set_bit(6, &data->i2c_state);
  227.  
  228.     /* Set/Clear bit */ 
  229.     state ? set_bit(1, &(data->i2c_state)) : clear_bit(1, &(data->i2c_state));
  230.  
  231.     gd_write_sr(data, data->i2c_state, 0x8);
  232. }
  233.  
  234. void gd54xx_setscl (void *bit_adap_dat, int state)
  235. {
  236.     struct clgd54xx_card *data=bit_adap_dat;
  237.  
  238.     set_bit(6, &data->i2c_state);
  239.     state ? set_bit(0, &(data->i2c_state)) : clear_bit(0, &(data->i2c_state));
  240.  
  241.     gd_write_sr(data, data->i2c_state, 0x8);
  242. }
  243.  
  244. int gd54xx_getsda (void *bit_adap_dat)
  245. {
  246.     struct clgd54xx_card *data=bit_adap_dat;
  247.  
  248.     return (((data->i2c_state = gd_read_sr(data, 0x8)) >>7)&0x1);
  249.  
  250.     return 0;
  251. }
  252.  
  253. int gd54xx_getscl (void *bit_adap_dat)
  254. {
  255.     struct clgd54xx_card *data=bit_adap_dat;
  256.     return (((data->i2c_state = gd_read_sr(data, 0x8)) >>2)&0x1);
  257.     return 0;
  258. }
  259.  
  260. /* Adapter functions - high level */
  261.  
  262. int i2c_clgd54xx_init_adapter(struct clgd54xx_card *card_p, 
  263.                   struct i2c_adapter * adap,
  264.                   struct i2c_algo_bit_data * bitadap)
  265. {
  266.  
  267.     /* Let's initialize some of the data structures.
  268.      * First plug in card adapter and card bit bang algo
  269.      * into card info.
  270.      */
  271.  
  272.     card_p->clgd54xx_adapter_p = adap;
  273.     card_p->clgd54xx_bitbang_adapter_p = bitadap;
  274.  
  275.     return     i2c_bit_add_bus(card_p->clgd54xx_adapter_p);
  276.  
  277. }
  278.  
  279. int i2c_clgd54xx_cleanup_adapter(struct clgd54xx_card *card_p){
  280.  
  281.     return i2c_bit_del_bus(card_p->clgd54xx_adapter_p);
  282. }
  283.  
  284. int i2c_clgd54xx_probe_card(struct clgd54xx_card *card_p)
  285. {
  286.     card_p->gd_io_base=0;
  287.     
  288.     /* Memory Mapped IO not supported at the moment.
  289.      * This driver won't work for multiple cards.
  290.      */
  291.     return 0;
  292. }
  293.  
  294. int i2c_clgd54xx_find_card(struct clgd54xx_card *card_p){
  295.     
  296.         struct pci_dev *dev = NULL;
  297.     int loop_count=0;
  298.     do{
  299.         if ((dev = pci_find_device(clgd54xx_card_id[MAX_CARDS],clgd54xx_card_id[loop_count], dev))) {
  300.  
  301.             printk(KERN_INFO
  302.                    "pvcl: Found %s\n", dev->name);
  303.             card_p->clgd54xx_pci_dev_p = dev;
  304.             card_p->clgd54xx_pci_dev_id =
  305.                 clgd54xx_card_id[loop_count];
  306.             
  307.             printk(KERN_INFO
  308.                    "pvcl: Detected %dMB video ram.\n",
  309.                    gd_count_ram(card_p));
  310.             
  311.             return 0;
  312.         }
  313.         loop_count++;
  314.     } while(clgd54xx_card_id[loop_count]!=clgd54xx_card_id[MAX_CARDS]);
  315.  
  316.     printk(KERN_WARNING
  317.            "pvcl: Sorry. Could not find a Cirrus Logic Chip.\n");
  318.     return -ENODEV;
  319.  
  320. }
  321.  
  322.  
  323. /*
  324.  *  gd_count_ram() is hacked from gd5480.c from the xtv package.
  325.  *  xtv is copyrighted to Itai Nahshon <nahshon@actcom.co.il>.
  326.  *  Used with permission from the author.
  327.  */
  328.  
  329.  
  330. int
  331. gd_count_ram(struct clgd54xx_card *card_p)
  332. {
  333.     int videoram = 1;
  334.     int SR0F, SR17;
  335.  
  336.     unsigned short chip_type = card_p->clgd54xx_pci_dev_id;
  337.  
  338.     switch (chip_type) {
  339.         case PCI_DEVICE_ID_CIRRUS_5446:
  340.         videoram = 1;
  341.     
  342.         SR0F = gd_read_sr(card_p, 0x0F);
  343.         SR17 = gd_read_sr(card_p, 0x17);
  344.         if ((SR0F & 0x18) == 0x18) {
  345.             if(SR0F & 0x80) {
  346.                 if(SR17 & 0x80)
  347.                     videoram = 2;
  348.                 else if(SR17 & 0x02)
  349.                     videoram = 3;
  350.                 else
  351.                     videoram = 4;
  352.             }
  353.             else {
  354.                 if((SR17 & 80) == 0)
  355.                     videoram = 2;
  356.             }
  357.         }
  358.         break;
  359.         
  360.     case PCI_DEVICE_ID_CIRRUS_5480:
  361.         videoram = 1;
  362.         SR0F = gd_read_sr(card_p, 0x0F);
  363.         if ((SR0F & 0x18) == 0x18) {    /* 2 or 4 MB */
  364.             videoram = 2;
  365.             if (SR0F & 0x80)    /* Second bank enable */
  366.                 videoram = 4;
  367.         }
  368.         break;
  369.         
  370.     case PCI_DEVICE_ID_CIRRUS_5465:
  371.         videoram = 4;
  372.         break;
  373.     }
  374.  
  375.     card_p->vram = videoram;
  376.     return videoram;
  377. }
  378.  
  379.  
  380. int __init i2c_clgd54xx_init(struct clgd54xx_card *card_p,
  381.                  struct i2c_adapter *adap,
  382.                  struct i2c_algo_bit_data *bitadap)
  383. {
  384.     int ret_val;
  385.  
  386.     /* This adapter is non-re-entrant at the moment */
  387.  
  388.     if(re_entry) return -EBUSY;
  389.  
  390.     re_entry = 1;
  391.  
  392.     if( (ret_val = i2c_clgd54xx_find_card(card_p)) ){
  393.         return ret_val;
  394.     }
  395.     
  396.     if( (ret_val = i2c_clgd54xx_probe_card(card_p)) ){
  397.         return ret_val;
  398.     }
  399.     
  400.     if( (ret_val = i2c_clgd54xx_init_adapter(card_p, adap, bitadap)) ){
  401.         return ret_val;
  402.     }
  403.     
  404.     return ret_val;
  405. }
  406.  
  407. int __init i2c_clgd54xx_cleanup(struct clgd54xx_card *card_p)
  408. {
  409.     re_entry=0;
  410.  
  411.     return i2c_clgd54xx_cleanup_adapter( card_p );
  412.     
  413. }
  414.  
  415. /* i2c client support */
  416. void do_client_ioctl(struct file *file, unsigned int cmd, void *arg)
  417. {
  418.     struct clgd54xx_card  *card_p = file->private_data;
  419.     struct i2c_adapter *adap = card_p->clgd54xx_adapter_p;
  420.     
  421.     int i;
  422.     
  423.         for (i = 0; i < I2C_CLIENT_MAX; i++) {
  424.                 if (NULL == adap->clients[i])
  425.                         continue;
  426.                 if (NULL == adap->clients[i]->driver->command)
  427.                         continue;
  428.                 adap->clients[i]->driver->command(
  429.                              adap->clients[i],cmd,arg);
  430.         }
  431.  
  432.     
  433. }
  434.  
  435. /* VGA support functions. */
  436.  
  437. /* gd_bit_copy() - used for copying data to/from VGA registers */
  438.  
  439. void gd_bit_copy(unsigned long * dest, int dest_start,  
  440.          unsigned long * src, int src_start, int src_stop)
  441. {
  442.     for(; src_start<= src_stop; src_start++, dest_start++)
  443.         {
  444.             if(test_bit(src_start, src))
  445.                 set_bit(dest_start, dest);
  446.             else
  447.                 clear_bit(dest_start, dest);
  448.         }
  449.                    
  450. }
  451.  
  452. void gd_enable_window(struct clgd54xx_card * card_p)
  453. {
  454.     unsigned long CR3E, CR50, CR51, CR58, CR5C;
  455.  
  456.     CR3E = gd_read_cr(card_p, 0x3e);
  457.     CR50 = gd_read_cr(card_p, 0x50);
  458.     CR51 = gd_read_cr(card_p, 0x51);
  459.     CR58 = gd_read_cr(card_p, 0x58);
  460.     CR5C = gd_read_cr(card_p, 0x5c);
  461.  
  462.     /* Disable Teletext CR5C[7] = 0 */
  463.      clear_bit(7,  &CR5C); 
  464.  
  465. /*     Capture all frames CR50[7], CR50[2], CR58[6] = 0,0,0 */
  466.  
  467.      clear_bit(7, &CR50); 
  468.      clear_bit(2, &CR50); 
  469.     clear_bit(6, &CR58); 
  470.     
  471.     /*    Set Capture input to VPORT CR50[1:0] = 11  */
  472.  
  473.     set_bit(0, &CR50);           /* Falling edge of HREF ends  */  
  474.     set_bit(1, &CR50);           /* capture line. */
  475.     
  476.     /* Enable Capture CR51[3] = 1 */
  477.       set_bit(3, &CR51); 
  478.     
  479.     /* Enable Video Window CR3E[0] = 1 */
  480.     set_bit(0, &CR3E);
  481.  
  482.     gd_write_cr(card_p, CR5C, 0x5c);
  483.     gd_write_cr(card_p, CR58, 0x58);
  484.     gd_write_cr(card_p, CR51, 0x51);
  485.     gd_write_cr(card_p, CR50, 0x50);
  486.     gd_write_cr(card_p, CR3E, 0x3e);
  487.  
  488. }
  489.  
  490. void gd_disable_window(struct clgd54xx_card * card_p)
  491. {
  492.     unsigned long CR3E, CR50, CR51;
  493.      
  494.     CR3E = gd_read_cr(card_p, 0x3e);
  495.     CR50 = gd_read_cr(card_p, 0x50);
  496.     CR51 = gd_read_cr(card_p, 0x51);
  497.  
  498.  
  499.     /*     Disable Capture CR51[3] = 0 */
  500.       clear_bit(3, &CR51);  
  501.  
  502.     /*    Reset Capture input to standard feature 
  503.         connector CR50[1:0] = 11  */
  504.  
  505.     clear_bit(0, &CR50);           /* Falling edge of HREF ends capture */
  506.     clear_bit(1, &CR50);  
  507.  
  508.     /* Disable Video Window CR3E[0] = 0 */
  509.     clear_bit(0, &CR3E);
  510.  
  511.  
  512.     gd_write_cr(card_p, CR51, 0x51);
  513.     gd_write_cr(card_p, CR50, 0x50);
  514.     gd_write_cr(card_p, CR3E, 0x3e);
  515. }
  516.  
  517. void gd_set_vbuf1(struct clgd54xx_card * card_p, unsigned long ptr)
  518. {
  519.         unsigned long CR3A, CR3B, CR3C, CR5D;
  520.  
  521.  
  522.     CR3A = gd_read_cr(card_p, 0x3a);
  523.     CR3B = gd_read_cr(card_p, 0x3b);
  524.     CR3C = gd_read_cr(card_p, 0x3c);
  525.     CR5D = gd_read_cr(card_p, 0x5d);
  526.  
  527.     /* CR5D[3:2] = ptr[1:0]  */
  528.  
  529.     gd_bit_copy( &CR5D, 2, &ptr, 0, 1);
  530.  
  531.     /* CR3A = ptr[9:2] */
  532.  
  533.     gd_bit_copy( &CR3A, 0, &ptr, 2, 9);
  534.  
  535.     
  536.     /* CR3B = ptr[17:10] */
  537.  
  538.     gd_bit_copy(&CR3B, 0, &ptr, 10, 17);
  539.  
  540.     /* CR3C[3:0] = ptr[21:18] */
  541.  
  542.     gd_bit_copy(&CR3C, 0, &ptr, 18, 21);
  543.  
  544.     gd_write_cr(card_p, CR3A, 0x3a);
  545.     gd_write_cr(card_p, CR3B, 0x3b);
  546.     gd_write_cr(card_p, CR3C, 0x3c);
  547.     gd_write_cr(card_p, CR5D, 0x5d);
  548.  
  549. }
  550.  
  551. void gd_set_vbuf2(struct clgd54xx_card * card_p, unsigned long ptr)
  552. {
  553.         unsigned long CR59, CR5A, CR58, CR5D;
  554.  
  555.     CR59 = gd_read_cr(card_p, 0x59);
  556.     CR5A = gd_read_cr(card_p, 0x5a);
  557.     CR58 = gd_read_cr(card_p, 0x58);
  558.     CR5D = gd_read_cr(card_p, 0x5d);
  559.  
  560.     /* CR5D[3:2] = ptr[1:0] */
  561.  
  562.     gd_bit_copy(&CR5D, 2, &ptr, 0, 1);
  563.  
  564.     /* CR59 = ptr[9:2]  */
  565.  
  566.     gd_bit_copy(&CR59, 0, &ptr, 2, 9);
  567.     
  568.     /* CR5A = ptr[17:10] */
  569.  
  570.     gd_bit_copy(&CR5A, 0, &ptr, 10, 17);
  571.  
  572.     /* CR58[3:0] = ptr[21:18] */
  573.  
  574.     gd_bit_copy(&CR58, 0, &ptr, 18, 21);
  575.  
  576.     gd_write_cr(card_p, CR59, 0x59);
  577.     gd_write_cr(card_p, CR5A, 0x5a);
  578.     gd_write_cr(card_p, CR58, 0x58);
  579.     gd_write_cr(card_p, CR5D, 0x5d);
  580.  
  581. }
  582.  
  583. unsigned long gd_get_vbuf1(struct clgd54xx_card * card_p)
  584. {
  585.         unsigned long CR3A, CR3B, CR3C, CR5D;
  586.     unsigned long ptr;
  587.  
  588.     CR3A = gd_read_cr(card_p, 0x3a);
  589.     CR3B = gd_read_cr(card_p, 0x3b);
  590.     CR3C = gd_read_cr(card_p, 0x3c);
  591.     CR5D = gd_read_cr(card_p, 0x5d);
  592.  
  593.     /*  ptr[1:0]  = CR5D[3:2] */
  594.     ptr = 0;
  595.     gd_bit_copy( &ptr, 0, &CR5D, 2, 3);
  596.  
  597.     /*  ptr[9:2] = CR3A */
  598.  
  599.     gd_bit_copy( &ptr, 2, &CR3A, 0, 7);
  600.  
  601.     
  602.     /* ptr[17:10] = CR3B */
  603.  
  604.     gd_bit_copy(&ptr, 10, &CR3B, 0, 7);
  605.  
  606.     /* ptr[21:18] = CR3C[3:0] */
  607.  
  608.     gd_bit_copy(&ptr, 18, &CR3C, 0, 3);
  609.  
  610.     return ptr;
  611.  
  612. }
  613.  
  614.  
  615. unsigned long gd_get_vbuf2(struct clgd54xx_card * card_p)
  616. {
  617.         unsigned long CR59, CR5A, CR58, CR5D;
  618.     unsigned long ptr;
  619.  
  620.     CR59 = gd_read_cr(card_p, 0x59);
  621.     CR5A = gd_read_cr(card_p, 0x5a);
  622.     CR58 = gd_read_cr(card_p, 0x58);
  623.     CR5D = gd_read_cr(card_p, 0x5d);
  624.  
  625.     /* ptr[1:0] = CR5D[3:2] */
  626.     ptr = 0;
  627.     gd_bit_copy(&ptr, 0, &CR5D, 2, 3);
  628.  
  629.     /* ptr[9:2] = CR59 */
  630.  
  631.     gd_bit_copy(&ptr, 2, &CR59, 0, 7);
  632.  
  633.     /* ptr[17:10] = CR5A */
  634.  
  635.     gd_bit_copy(&ptr, 10, &CR5A, 0, 7);
  636.  
  637.     /* ptr[21:18] = CR58[3:0] */
  638.     
  639.     gd_bit_copy(&ptr, 18, &CR58, 0, 3);
  640.     return ptr;
  641.  
  642. }
  643.  
  644. void gd_set_pitch(struct clgd54xx_card * card_p, unsigned long offset)
  645. {
  646.     unsigned long CR3C, CR3D;
  647.     
  648.     CR3C = gd_read_cr(card_p, 0x3c);
  649.     CR3D = gd_read_cr(card_p, 0x3d);
  650.  
  651.     /* CR3C[5] = offset[11], CR3D = offset[10:3] */
  652.  
  653.     gd_bit_copy(&CR3C, 5, &offset ,11, 11);
  654.  
  655.     gd_bit_copy(&CR3D, 0, &offset, 3, 10);
  656.  
  657.     gd_write_cr(card_p, CR3C, 0x3c);
  658.     gd_write_cr(card_p, CR3D, 0x3d);
  659.  
  660. }
  661.  
  662.  
  663. unsigned long gd_get_pitch(struct clgd54xx_card * card_p)
  664. {
  665.  
  666.     unsigned long CR3C, CR3D;
  667.     unsigned long offset ;
  668.  
  669.  
  670.         CR3C = gd_read_cr(card_p, 0x3c);
  671.         CR3D = gd_read_cr(card_p, 0x3d);
  672.     
  673.     /* offset[11] = CR3C[5] , offset[10:3] = CR3D */
  674.     offset = 0;
  675.     gd_bit_copy(&offset, 11, &CR3C, 5, 5);
  676.     gd_bit_copy(&offset, 3, &CR3D, 0, 7);
  677.  
  678.     return offset;
  679. }
  680.  
  681.  
  682.  
  683. void gd_init_video( struct clgd54xx_card * card_p )
  684. {
  685.     unsigned long temp_reg;
  686.     unsigned long  CR31, CR32, CR3E, CR3F, CR50, CR51, CR56, 
  687.         CR57, CR58, CR5C, CR5E;
  688.  
  689. /*     unsigned long GRC, GRD; */
  690.  
  691.     CR31 = gd_read_cr(card_p, 0x31);
  692.     CR32 = gd_read_cr(card_p, 0x32);
  693.     CR3E = gd_read_cr(card_p, 0x3e);
  694.     CR3F = gd_read_cr(card_p, 0x3f);
  695.     CR50 = gd_read_cr(card_p, 0x50);
  696.     CR51 = gd_read_cr(card_p, 0x51);
  697.     CR56 = gd_read_cr(card_p, 0x56);
  698.     CR57 = gd_read_cr(card_p, 0x57);
  699.     CR58 = gd_read_cr(card_p, 0x58); /* Dependancy only on maxheight */
  700.     CR5C = gd_read_cr(card_p, 0x5c);
  701.     CR5E = gd_read_cr(card_p, 0x5e);
  702.  
  703.  
  704.     /*     GRC = gd_read_gr(card_p, 0x0c); */
  705.     /*     GRD = gd_read_gr(card_p, 0x0d); */
  706.  
  707.     /* Set the maximum scanlines to 512, we don't want 
  708.      *  wanton clipping. */
  709.  
  710.     temp_reg = 0xff;
  711.     gd_bit_copy(&CR57, 0, &temp_reg, 0, 7);
  712.     set_bit(5, &CR58);
  713.  
  714.     /* Luminance only capture disabled */
  715.     /* CR5C[5] = 0 */
  716.     
  717.     clear_bit(5, &CR5C);
  718.  
  719.     /* Count lines upto capture, set to zero */
  720.     /* CR56[4:0] = 0 */
  721.  
  722.     temp_reg = 0;
  723.     gd_bit_copy(&CR56, 0, &temp_reg, 0, 4);
  724.  
  725.     /* Non - Interlaced capture */
  726.     /* CR50[6] = 0 */
  727.  
  728.     clear_bit(6, &CR50);
  729.  
  730.     /* 8bits, VPort width */
  731.     /* CR50[4] = 0; */
  732.  
  733.     clear_bit(4, &CR50);
  734.  
  735.     /* Double clock capture */
  736.     /* CR50[3] = 1; */
  737.     
  738.     set_bit(3, &CR50);
  739.       
  740.  
  741.     /* Video Capture (Not Teletext) */
  742.     /* CR5C[7] = 0 */
  743.  
  744.     clear_bit(7, &CR5C);
  745.  
  746.     /* Capture Data Format - YUV 4:2:2 */
  747.     /* CR51[2:0] = 000 */
  748.  
  749.     clear_bit(0, &CR51);
  750.     clear_bit(1, &CR51);
  751.     clear_bit(2, &CR51);
  752.  
  753.     /* Display Data Format - YUV 4:2:2 */
  754.     /* CR3E[3:1] = 000 */
  755.     /* CR3F[4] = 0 */
  756.  
  757.     clear_bit(1, &CR3E);
  758.     clear_bit(2, &CR3E);
  759.     clear_bit(3, &CR3E);
  760.     clear_bit(4, &CR3F);
  761.  
  762.     /* Double Buffer Control - Autoswitch */
  763.     /* CR5E[5:4] = 10 */
  764.  
  765.     clear_bit(4, &CR5E);
  766.     set_bit(5, &CR5E);
  767.  
  768.  
  769.     /* Set Zoom = 1:1 ie., ZoomX = ZoomY = 0 */
  770.     /* ZoomX = CR31, ZoomY = CR32 */
  771.     CR31 = CR32 = 0;
  772.     
  773.     /* Also, Zoom mode set to 1; ie; line replication, 
  774.      * in anticipation of chromakeying..
  775.      */
  776.     set_bit(4, &CR3E);
  777.  
  778.     /* Occlusion set to Colour Key, tagged compare (16 bit). */
  779.     /* CR1D[5:3] = 011 */
  780.  
  781.     /*     set_bit(3, &CR1D); */
  782.     /*     clear_bit(4, &CR1D); */
  783.     /*     clear_bit(5, &CR1D); */
  784.        
  785.  
  786.  
  787.     /* Set the Chroma key. */
  788.  
  789.     /*     GRC = 0; */
  790.     /*     GRD = GD_CHROMA_KEY; */
  791.        
  792.     /* Switch on Chromakeying */
  793.     /*     set_bit(7, &CR3E); */
  794.  
  795.     /*     gd_write_gr(card_p, GRC, 0x0c); */
  796.     /*     gd_write_gr(card_p, GRD, 0x0d); */
  797.  
  798.     gd_write_cr(card_p, CR50, 0x50);
  799.     gd_write_cr(card_p, CR51, 0x51);
  800.     gd_write_cr(card_p, CR56, 0x56);
  801.     gd_write_cr(card_p, CR57, 0x57);
  802.     gd_write_cr(card_p, CR58, 0x58); /* May be safely removed with Mx ht.*/
  803.     gd_write_cr(card_p, CR5C, 0x5c);
  804.     gd_write_cr(card_p, CR5E, 0x5e);
  805.     gd_write_cr(card_p, CR31, 0x31);
  806.     gd_write_cr(card_p, CR32, 0x32);
  807.     gd_write_cr(card_p, CR3E, 0x3e);
  808.     gd_write_cr(card_p, CR3F, 0x3f);
  809. }
  810.  
  811. void gd_get_window(struct clgd54xx_card * card_p,
  812.            struct video_window *winstruct,
  813.            struct video_buffer * vbuf)
  814. {
  815.     int depth;
  816.     unsigned long R1SZ, R1Adjust, R2SZ, R2Adjust, R2DSZ, WVS, WVE, WAO;
  817.      unsigned long CR33, CR34, CR35, CR36, CR37, CR38, CR39, CR5D;
  818.  
  819.     depth = (vbuf->depth == 32 ? 24 : vbuf->depth);
  820.         CR33 = gd_read_cr(card_p, 0x33);
  821.     CR34 = gd_read_cr(card_p, 0x34);
  822.     CR35 = gd_read_cr(card_p, 0x35);
  823.     CR36 = gd_read_cr(card_p, 0x36);
  824.     CR37 = gd_read_cr(card_p, 0x37);
  825.     CR38 = gd_read_cr(card_p, 0x38);
  826.     CR39 = gd_read_cr(card_p, 0x39);
  827.     CR5D = gd_read_cr(card_p, 0x5d);
  828.  
  829.  
  830.     /* R1SZ = CR36[1:0] CR33 */
  831.     R1SZ = 0;
  832.     gd_bit_copy(&R1SZ, 8, &CR36, 0, 1);
  833.     gd_bit_copy(&R1SZ, 0, &CR33, 0, 7);
  834.     
  835.     /* R1Adjust = CR5D[1:0] */
  836.  
  837.     R1Adjust = 0;
  838.     gd_bit_copy(&R1Adjust, 0, &CR5D, 0, 1);
  839.  
  840.     /* R2SZ = CR36[3:2] CR34 */
  841.     R2SZ = 0;
  842.     gd_bit_copy(&R2SZ, 8, &CR36, 2, 3);
  843.     gd_bit_copy(&R2SZ, 0, &CR34, 0, 7);
  844.  
  845.     /* R2Adjust = CR5D[5:4] */
  846.     R2Adjust = 0;
  847.     gd_bit_copy(&R2Adjust, 0, &CR5D, 4, 5);
  848.  
  849.     /* R2DSZ = CR36[5:4] CR35 */
  850.     R2DSZ = 0;
  851.     gd_bit_copy(&R2DSZ, 8, &CR36, 4, 5);
  852.     gd_bit_copy(&R2DSZ, 0, &CR35, 0, 7);
  853.  
  854.     /* WVS = CR39[1:0] CR37 */
  855.     WVS = 0;
  856.     gd_bit_copy(&WVS, 8, &CR39, 0, 1);
  857.     gd_bit_copy(&WVS, 0, &CR37, 0, 7);
  858.  
  859.     /* WVE = CR39[3:2] CR38 */
  860.     WVE = 0;
  861.     gd_bit_copy(&WVE, 8, &CR39, 2, 3);
  862.     gd_bit_copy(&WVE, 0, &CR38, 0, 7);
  863.  
  864.     WAO = 0;
  865.  
  866.     WAO = gd_get_pitch(card_p);
  867.  
  868.  
  869.     tprintk("gd_get_window() hardware registers read:\n
  870.                 depth = %d bpp \n
  871.                 R1SZ = %ld\n
  872.                 R1Adjust = %ld\n
  873.                 R2SZ = %ld\n 
  874.                 R2Adjust = %ld\n 
  875.                 R2DSZ = %ld\n 
  876.                 WVS=%ld\n WVE=%ld\n 
  877.                 WAO=%ld\n", depth,
  878.         R1SZ, R1Adjust, R2SZ, R2Adjust, R2DSZ, WVS, WVE, WAO);
  879.  
  880.     winstruct->x = R1SZ * 32 / depth + R1Adjust * 8 / depth;
  881.  
  882.     winstruct->width = R2SZ * 32 / depth + R2Adjust * 8 / depth;
  883.  
  884.     winstruct->y = WVS;
  885.     winstruct->height = WVE - WVS;
  886.  
  887. }
  888.  
  889.  
  890. void gd_set_window(struct clgd54xx_card * card_p,
  891.            struct video_window *winasked,
  892.            struct video_window *wingiven,
  893.            struct video_buffer *vbuf)
  894. {
  895.     int depth;
  896.     unsigned long R1SZ, R1Adjust, R2SZ, R2Adjust, R2DSZ, WVS, WVE, WAO;
  897.     unsigned ZOOMY, CR32;
  898.     unsigned long CR33, CR34, CR35, CR36, CR37, CR38, CR39, CR5D;
  899.  
  900.     depth = (vbuf->depth == 32 ? 24 : vbuf->depth);
  901.  
  902.     /* Safety Checks and clipping, for window borders. */
  903.  
  904.     winasked->x = winasked->x < 0 ?
  905.         0 : winasked->x;
  906.  
  907.     winasked->y = winasked->y < 0 ?
  908.         0 : winasked->y;
  909.         
  910.     winasked->width = (vbuf->width - winasked->x) < winasked->width ?
  911.         (vbuf->width - winasked->x) : winasked->width;
  912.  
  913.     winasked->height = (vbuf->height - winasked->y) < winasked->height ?
  914.         (vbuf->height - winasked->y) : winasked->height;
  915.  
  916.  
  917.     R1SZ = (winasked->x * depth) / 32;
  918.     R1Adjust = (winasked->x * depth - R1SZ * 32) / 8;
  919.     
  920.     R2SZ = (winasked->width * depth) / 32;
  921.     R2Adjust = (winasked->width * depth - R2SZ * 32) / 8;
  922.  
  923.     /*ugly hack. only tried on 24bpp and 16bpp eqn is. vbpp/gbpp * .5 */
  924.  
  925.     R2DSZ = R2SZ * 16 / depth + R2Adjust * 4 / depth;
  926.  
  927.     WVS = winasked->y;
  928.  
  929.     WVE = WVS + winasked->height;
  930.  
  931.     WAO = R2SZ * 4; 
  932.  
  933.     /* Zoom treatment. Doing zoom just for Vlines.
  934.      * Notes: Occlusion, ie; chromakeying and line interpolation 
  935.      * (in the case of zooming) are mutually exclusive. 
  936.      */
  937.     
  938.     if(wingiven->height < winasked->height)
  939.         {
  940.             ZOOMY = (wingiven->height * 256) / winasked->height - 5;
  941.             CR32 = ZOOMY;
  942.         }
  943.     else
  944.         CR32 = 0;      /* Don't want old Zoom values lying about. */
  945.             
  946.             
  947.  
  948.     /* CR36[1:0] CR33 = R1SZ */
  949.     gd_bit_copy(&CR36, 0, &R1SZ, 8, 9);
  950.     gd_bit_copy(&CR33, 0, &R1SZ, 0, 7);
  951.     
  952.     /* CR5D[1:0] = R1Adjust */
  953.     gd_bit_copy(&CR5D, 0, &R1Adjust, 0, 1);
  954.  
  955.     /* CR36[3:2] CR34 = R2SZ */
  956.     gd_bit_copy(&CR36, 2, &R2SZ, 8, 9);
  957.     gd_bit_copy(&CR34, 0, &R2SZ, 0, 7);
  958.  
  959.     /* CR5D[5:4] = R2Adjust */
  960.     
  961.     gd_bit_copy(&CR5D, 4, &R2Adjust, 0, 1);
  962.  
  963.     /* CR36[5:4] CR35 = R2DSZ */
  964.     
  965.     gd_bit_copy(&CR36, 4, &R2DSZ, 8, 9);
  966.     gd_bit_copy(&CR35, 0, &R2DSZ, 0, 7);
  967.  
  968.     /* CR39[1:0] CR37 = WVS */
  969.     
  970.     gd_bit_copy(&CR39, 0, &WVS, 8, 9);
  971.     gd_bit_copy(&CR37, 0, &WVS, 0, 7);
  972.  
  973.     /* CR39[3:2] CR38 = WVE */
  974.     
  975.     gd_bit_copy(&CR39, 2, &WVE, 8, 9);
  976.     gd_bit_copy(&CR38, 0, &WVE, 0, 7);
  977.  
  978.     /* CR36[5:4] CR35 = R2DSZ */
  979.  
  980.     gd_bit_copy(&CR36, 4, &R2DSZ, 8, 9);
  981.     gd_bit_copy(&CR35, 0, &R2DSZ, 0, 7);
  982.  
  983.     gd_set_pitch(card_p, WAO);
  984.  
  985.     tprintk("gd_set_window() hardware registers set to:\n
  986.                 R1SZ = %ld\n
  987.                 R1Adjust = %ld\n
  988.                 R2SZ = %ld\n 
  989.                 R2Adjust = %ld\n 
  990.                 R2DSZ = %ld\n 
  991.                 WVS=%ld\n WVE=%ld\n 
  992.                 WAO=%ld\n", 
  993.         R1SZ, R1Adjust, R2SZ, R2Adjust, R2DSZ, WVS, WVE, WAO);
  994.  
  995.           gd_write_cr(card_p, CR5D, 0x5d);  
  996.         gd_write_cr(card_p, CR39, 0x39);  
  997.         gd_write_cr(card_p, CR38, 0x38);  
  998.         gd_write_cr(card_p, CR37, 0x37);  
  999.         gd_write_cr(card_p, CR36, 0x36);  
  1000.         gd_write_cr(card_p, CR35, 0x35);  
  1001.         gd_write_cr(card_p, CR34, 0x34);  
  1002.         gd_write_cr(card_p, CR33, 0x33);  
  1003.         gd_write_cr(card_p, CR32, 0x32);  
  1004. }
  1005.  
  1006. /* returns clipped windows, according to available ram, with
  1007.  * video buffer starting as close to the end of video ram as possible.
  1008.  */
  1009.  
  1010. long gd_window_init(struct clgd54xx_card * card_p)
  1011. {
  1012.  
  1013.     int scrn_depth;
  1014.     unsigned long vbuf1_ptr, vbuf2_ptr, scrn_ht, scrn_wt, vram;
  1015.  
  1016.     vram = card_p->vram = gd_count_ram(card_p);
  1017.  
  1018.     scrn_ht = card_p->drv_stat_p->vbuf_p->height;
  1019.     scrn_wt = card_p->drv_stat_p->vbuf_p->width;
  1020.     scrn_depth = card_p->drv_stat_p->vbuf_p->depth;
  1021.     scrn_depth = scrn_depth == 32 ? 24 :scrn_depth;
  1022.  
  1023.     vbuf1_ptr = vram * 1048576 - 16384 - scrn_ht * scrn_wt * 2;
  1024.  
  1025.     /* Eeeks!!! No check for video data spilling over into framebuffer
  1026.      * space. OK folk. Get ready for full screen video! 
  1027.  
  1028.     if(vbuf1_ptr < (scrn_ht * scrn_wt * scrn_depth / 8)) return -1;
  1029.     
  1030.     */
  1031.  
  1032.     vbuf2_ptr = vbuf1_ptr;
  1033.  
  1034.     gd_init_video(card_p);
  1035.  
  1036.     printk("Marker \n");
  1037.  
  1038.     gd_set_vbuf1(card_p, vbuf1_ptr);
  1039.     gd_set_vbuf2(card_p, vbuf2_ptr);
  1040.  
  1041.     return vbuf2_ptr;
  1042.  
  1043. }
  1044.  
  1045. /* V4L Driver Callback functions */
  1046.  
  1047. static int pvcl_open(struct inode *inode, struct file *file)
  1048. {
  1049.  
  1050.     unsigned int minor = minor(inode->i_rdev);
  1051.     struct clgd54xx_card * card_p;
  1052.  
  1053.  
  1054.     file->private_data = &clgd54xx_card_info;
  1055.     card_p = file->private_data;
  1056.  
  1057.     do_client_ioctl(file, VPROC_INIT, &card_p->model);
  1058.  
  1059.     dprintk("pvcl_open called on minor %d\n", minor);
  1060.  
  1061.     return 0;
  1062. }
  1063.  
  1064. static int pvcl_release(struct inode *inode, struct file *file)
  1065. {
  1066.     file->private_data = NULL;
  1067.     
  1068.     dprintk("pvcl_release called.\n");
  1069.     return 0;
  1070. }
  1071.  
  1072. static int pvcl_do_ioctl(struct inode *inode, struct file *file,
  1073.                unsigned int cmd, void *arg)
  1074. {
  1075.  
  1076.     struct clgd54xx_card * card_p = file->private_data;
  1077.  
  1078.     switch(cmd) {
  1079.         
  1080.     case VIDIOCGCAP:
  1081.         {
  1082.             struct video_capability *cap = arg; 
  1083.             struct video_buffer *bufstat = 
  1084.                 card_p->drv_stat_p->vbuf_p;
  1085.  
  1086.             sprintf(cap->name, "pvcl");
  1087.             
  1088.             cap->type = VID_TYPE_TUNER | VID_TYPE_OVERLAY | 
  1089.                 VID_TYPE_FRAMERAM  | VID_TYPE_SCALES;
  1090.             
  1091.             cap->channels = 1; /* Just one channel for now. */
  1092.             cap->audios = 1;
  1093.  
  1094.             /* Max Screen Size reported by X11 via v4l-conf */
  1095.             cap->maxwidth = bufstat->width;    
  1096.             cap->maxheight = bufstat->height;  
  1097.             cap->minwidth = 32;  /* Hardcoded vpx 3225D specific */
  1098.             cap->minheight = 24;
  1099.             
  1100.             /* Hard Code PAL for the moment. */
  1101.  
  1102.             do_client_ioctl(file, VPROC_SET_CAP_MODE,
  1103.                     &card_p->drv_stat_p->vtun_p->mode);
  1104.  
  1105.             dprintk("VIDIOCGCAP called\n");
  1106.         
  1107.             return 0;
  1108.         }
  1109.  
  1110.     case VIDIOCGFBUF:
  1111.         {
  1112.             struct video_buffer *buf = arg;
  1113.             struct video_buffer *bufstat = 
  1114.                 card_p->drv_stat_p->vbuf_p;
  1115.  
  1116.             memcpy(buf, bufstat, sizeof(*buf));
  1117.  
  1118.             dprintk("VIDIOCGFBUF called. \n");
  1119.  
  1120.             return 0;
  1121.  
  1122.         }
  1123.         
  1124.     case VIDIOCSFBUF:
  1125.         {
  1126.             
  1127.             struct video_buffer *buf = arg;
  1128.             struct video_buffer *bufstat = 
  1129.                 card_p->drv_stat_p->vbuf_p;
  1130.  
  1131.  
  1132.             /* HEEEEEEEEEEEEELOOOOOOOOOOOOOOOO, Careful. Security 
  1133.                hole here!!!!!!!!!!! 
  1134.             */
  1135.             /* Security check disabled for now.
  1136.                if(!capable(CAP_SYS_ADMIN) &&
  1137.                !capable(CAP_SYS_RAWIO))
  1138.                return -EPERM;
  1139.             */
  1140.  
  1141.             memcpy(bufstat, buf, sizeof(*bufstat));
  1142.             
  1143.             dprintk("VIDIOCSFBUF called. \n");
  1144.             printk(KERN_INFO "client reports:\n
  1145.                               screen size: %dx%d @ %dbpp. 
  1146.                               %d bytesperline.\n.", 
  1147.                    bufstat->width, 
  1148.                    bufstat->height, 
  1149.                    bufstat->depth, 
  1150.                    bufstat->bytesperline);
  1151.  
  1152.             dprintk("Capture Buffer set to 0x%p", bufstat->base);
  1153.  
  1154.             /* Now that we've got the Screen Parms, 
  1155.              * we can inititialize the window */
  1156.  
  1157.             gd_window_init(card_p); 
  1158.  
  1159.             return 0;
  1160.         }
  1161.         
  1162.         
  1163.     case VIDIOCCAPTURE:
  1164.         {
  1165.             int *on = arg;
  1166.             struct video_buffer *bufstat = 
  1167.                 card_p->drv_stat_p->vbuf_p;
  1168.             
  1169.             if (*on) {
  1170.                 /* verify args */
  1171.                 if (NULL == bufstat->base)
  1172.                     return -EINVAL;
  1173.                 if (bufstat->width <32 ||
  1174.                     bufstat->height <24 ||
  1175.                     bufstat->width >800 ||
  1176.                     bufstat->height >600)
  1177.                     
  1178.                     return -EINVAL;
  1179.             }
  1180.  
  1181.             if(*on) {
  1182.                 
  1183.  
  1184.                 /* Tell vpx to switch on. `on' is dummy here.*/
  1185.  
  1186.                 do_client_ioctl(file, VPROC_START_CAPTURE, on);
  1187.                 gd_enable_window(card_p); 
  1188.                 
  1189.                 dprintk("VIDIOCCAPTURE: video window switched on. \n");
  1190.                 return 0;
  1191.             }
  1192.  
  1193.             else {
  1194.  
  1195.                 /* Tell vpx to stop capture. `on'  is dummy.*/
  1196.  
  1197.                 do_client_ioctl(file, VPROC_STOP_CAPTURE, on);
  1198.  
  1199.                 gd_disable_window(card_p); 
  1200.  
  1201.                 dprintk("VIDIOCCAPTURE: video window switched off. \n");
  1202.                 return 0;
  1203.             }
  1204.                 
  1205.         }
  1206.         
  1207.     case VIDIOCGWIN:
  1208.         {
  1209.             struct video_window *winarg = arg;
  1210.             struct video_window *winstat = 
  1211.                 card_p->drv_stat_p->vwin_p;
  1212.             
  1213.             memcpy(winarg, winstat, sizeof(*winarg));
  1214.  
  1215.             /* TODO: Need to get actual window parms from
  1216.              * hardware. Use gd_get_video_window()
  1217.              */
  1218.  
  1219.             dprintk("VIDIOCGWIN called. \n");
  1220.             return 0;
  1221.         }
  1222.  
  1223.  
  1224.     case VIDIOCSWIN:
  1225.         {
  1226.             struct video_window *winarg = arg;
  1227.                         struct video_window *winstat = 
  1228.                 card_p->drv_stat_p->vwin_p;
  1229.             struct video_buffer *bufstat = 
  1230.                 card_p->drv_stat_p->vbuf_p;
  1231.  
  1232.              memcpy(winstat, winarg, sizeof(*winstat));
  1233.  
  1234.  
  1235.             tprintk("VIDIOCSWIN recieved:\n 
  1236.                                 \t position:   %d, %d \n 
  1237.                                 \t dimensions: %d, %d \n",
  1238.                                 winstat->x,
  1239.                 winstat->y, 
  1240.                 winstat->width, 
  1241.                 winstat->height); 
  1242.  
  1243.             do_client_ioctl(file, VPROC_SET_WINDOW, winarg); 
  1244.  
  1245.             /* gd_set_window(card_p, app_wants, vproc_gives....) */
  1246.  
  1247.             gd_set_window(card_p, winstat, winarg, bufstat); 
  1248.  
  1249.             tprintk("gd_set_window() recieved:\n 
  1250.                                 \t position:   %d, %d \n 
  1251.                                 \t dimensions: %d, %d \n",
  1252.                                 winstat->x,
  1253.                 winstat->y, 
  1254.                 winstat->width, 
  1255.                 winstat->height); 
  1256.  
  1257.                gd_get_window(card_p, winstat, bufstat);   
  1258.  
  1259.             tprintk("gd_get_window returned: \n 
  1260.                                 \t position:   %d, %d \n 
  1261.                                 \t dimensions: %d, %d \n",
  1262.                                 winstat->x,
  1263.                 winstat->y, 
  1264.                 winstat->width, 
  1265.                 winstat->height); 
  1266.  
  1267.  
  1268.                         dprintk("VIDIOCSWIN called. \n");
  1269.                         return 0;
  1270.                 }
  1271.  
  1272.         /* Wrappers for tuner.c - hacked from bttv-driver.c 
  1273.            which is copyrighted to :
  1274.          
  1275.            Copyright (C) 1996,97,98 
  1276.            Ralph  Metzler <rjkm@thp.uni-koeln.de>,
  1277.            Marcus Metzler <mocm@thp.uni-koeln.de>,
  1278.            &
  1279.            (c) 1999-2002 Gerd Knorr <kraxel@bytesex.org>
  1280.  
  1281.         */
  1282.         
  1283.         case VIDIOCGTUNER:
  1284.         {
  1285.             struct video_tuner *v = arg;
  1286.             struct video_tuner *vstat = 
  1287.                 card_p->drv_stat_p->vtun_p;
  1288.  
  1289.             if (v->tuner) /* Only tuner 0 */
  1290.                 return -EINVAL;
  1291.  
  1292.             do_client_ioctl(file,cmd,v);
  1293.  
  1294.             /* tuner.c returns v->signal, ie; signal strength. */
  1295.             memcpy(v, vstat, sizeof(*v));
  1296.  
  1297.             dprintk("VIDIOCGTUNER has been called. \n");
  1298.             return 0;
  1299.  
  1300.         }                    
  1301.         
  1302.         case VIDIOCSTUNER:
  1303.         {
  1304.             struct video_tuner *v = arg;
  1305.             struct video_tuner *vstat = 
  1306.                 card_p->drv_stat_p->vtun_p;
  1307.  
  1308.             if (v->tuner) /* Only tuner 0 */
  1309.                 return -EINVAL;
  1310.             if (v->mode > VIDEO_MODE_PAL)
  1311.                 return -EINVAL;
  1312.             
  1313.             do_client_ioctl(file,cmd,v);
  1314.  
  1315.             vstat->mode = v->mode;
  1316.  
  1317.             dprintk("VIDIOCSTUNER has been called. \n");
  1318.  
  1319.             return 0;
  1320.         }
  1321.  
  1322.         case VIDIOCGFREQ:
  1323.         {
  1324.             unsigned long *freq = arg;
  1325.             *freq = card_p->drv_stat_p->freq;
  1326.             dprintk("VIDIOCGFREQ called.\n");
  1327.         
  1328.             return 0;
  1329.         }
  1330.         case VIDIOCSFREQ:
  1331.         {
  1332.             unsigned long *freq = arg;
  1333.  
  1334.             do_client_ioctl(file,cmd,freq);
  1335.             
  1336.             card_p->drv_stat_p->freq=*freq;
  1337.             dprintk("VIDIOCSFREQ called.\n");
  1338.  
  1339.             return 0;
  1340.         }
  1341.  
  1342.         case VIDIOCSCHAN:
  1343.         {
  1344.             struct video_channel *v = arg;
  1345.             struct video_tuner *vstat = card_p->drv_stat_p->vtun_p;
  1346.  
  1347.             if (v->channel >  0)
  1348.                 return -EINVAL;
  1349.  
  1350.             if(v->norm > VIDEO_MODE_PAL)
  1351.                 return -EINVAL;
  1352.  
  1353.             /* TODO: need to implement tv norms. 
  1354.              * Currently hardcoded
  1355.              * to PAL. See struct video_channel 
  1356.              * vchan_s decl above. */
  1357.  
  1358.             do_client_ioctl(file,cmd,v);
  1359.  
  1360.             memcpy(vstat, v , sizeof(*v));
  1361.             dprintk("VIDIOCSCHAN has been called. \n");
  1362.             return 0;
  1363.         }
  1364.         
  1365.         case VIDIOCGCHAN:
  1366.         {
  1367.             struct video_channel *v = arg;
  1368.             struct video_channel *chanstat = 
  1369.                 card_p->drv_stat_p->vchan_p;
  1370.  
  1371.             memcpy(v, chanstat, sizeof(*v));
  1372.  
  1373.             dprintk("VIDIOCGCHAN has been called. \n");
  1374.  
  1375.             return 0;
  1376.         }
  1377.  
  1378.         /* End bttv-driver.c wrappers. */
  1379.  
  1380.  
  1381.     case VIDIOCGPICT:
  1382.         {
  1383.             struct video_picture *vpict = arg;
  1384.             struct video_picture *vpictstat =
  1385.                 card_p->drv_stat_p->vpict_p;
  1386.  
  1387.             memcpy(vpict, vpictstat, sizeof(*vpict));
  1388.  
  1389.             dprintk("VIDIOCGPICT has been called. \n");
  1390.         }
  1391.  
  1392.  
  1393.     case VIDIOCSPICT:
  1394.         {
  1395.             struct video_picture *vpict = arg;
  1396.             struct video_picture *vpictstat =
  1397.                 card_p->drv_stat_p->vpict_p;
  1398.  
  1399.             memcpy(vpictstat, vpict, sizeof(*vpict));
  1400.  
  1401.             do_client_ioctl(file, VPROC_SET_PICTURE, vpictstat);
  1402.             
  1403.             dprintk("VIDIOCGPICT has been called. \n");
  1404.         }
  1405.     }    
  1406.     
  1407.     return -ENOIOCTLCMD;
  1408.     
  1409.  
  1410.     
  1411. }
  1412.  
  1413.  
  1414. static int pvcl_ioctl(struct inode *inode, struct file *file,
  1415.             unsigned int cmd, unsigned long arg)
  1416. {
  1417.     return video_usercopy(inode, file, cmd, arg, pvcl_do_ioctl);
  1418. }
  1419.  
  1420. static ssize_t pvcl_read(struct file *file, char *data,
  1421.                size_t count, loff_t *ppos)
  1422. {
  1423.     return 0;
  1424. }
  1425.  
  1426. static struct file_operations pvcl_fops =
  1427. {
  1428.     owner:      THIS_MODULE,
  1429.     open:       pvcl_open,
  1430.     release:    pvcl_release,
  1431.     ioctl:      pvcl_ioctl,
  1432.     llseek:     no_llseek,
  1433.     read:       pvcl_read
  1434. };
  1435.  
  1436. static struct video_device pvcl_video_dev =
  1437. {
  1438.     name:      "PVCL ver 0.1",
  1439.     type:       VID_TYPE_TUNER | VID_TYPE_OVERLAY |
  1440.                     VID_TYPE_FRAMERAM | VID_TYPE_SCALES,
  1441.     fops:       &pvcl_fops,
  1442.     minor:      -1
  1443. };
  1444.  
  1445.  
  1446. /* Device Registration */
  1447. static int __devinit pvcl_register_video(struct video_device * video_dev )
  1448. {
  1449.     if(video_register_device(video_dev, VFL_TYPE_GRABBER, 0)<0)
  1450.         return -1;
  1451.     printk(KERN_INFO "pvcl: registered device video\n");
  1452.  
  1453.     return 0;
  1454.  
  1455.  
  1456. }
  1457.  
  1458. static void __devexit pvcl_unregister_video(struct video_device * video_dev)
  1459. {
  1460.     video_unregister_device(video_dev);
  1461. }
  1462.  
  1463. static int pvcl_init_module(void)
  1464. {
  1465.     int retval;
  1466.  
  1467.     if( (retval = pvcl_register_video( &pvcl_video_dev)) ) return retval;
  1468.     if( (retval = i2c_clgd54xx_init(&clgd54xx_card_info, 
  1469.                     &clgd54xx_adap,
  1470.                     &clgd54xx_bitbang_adap)) )
  1471.         return retval;
  1472.  
  1473.     switch(debug)
  1474.         {
  1475.         case 1:
  1476.             {
  1477.                 printk(KERN_INFO "pvcl: Functional Debug messages enabled.\n");
  1478.                 break;
  1479.             }
  1480.         case 2:
  1481.             {
  1482.                 printk(KERN_INFO "pvcl: Debug messages enabled per function.\n");
  1483.                 break;
  1484.             }
  1485.         case 3:
  1486.             printk(KERN_INFO "pvcl: WARNING: Verbose Debugging enabled - kernel printk buffers may overflow.\n");
  1487.             break;
  1488.         }
  1489.  
  1490.  
  1491.     return retval;
  1492.  
  1493. }
  1494.  
  1495. static void pvcl_cleanup_module(void)
  1496. {
  1497.     i2c_clgd54xx_cleanup(&clgd54xx_card_info);
  1498.     pvcl_unregister_video(&pvcl_video_dev);
  1499. }
  1500.  
  1501. module_init(pvcl_init_module);
  1502. module_exit(pvcl_cleanup_module);
  1503.  
  1504. MODULE_PARM(debug,"i");
  1505. MODULE_PARM_DESC(debug,"debug messages, default 0, is don't debug.");
  1506.  
  1507. MODULE_DESCRIPTION("pvcl - v4l driver module for the pixelview combo tv plus");
  1508. MODULE_AUTHOR("Cherry George Mathew");
  1509. MODULE_LICENSE("GPL");
  1510.  
  1511. /*
  1512.  * Local variables:
  1513.  * c-basic-offset: 8
  1514.  * End:
  1515.  */
  1516.